const dayjs = require('dayjs');
const cloudHelper = require('../../../config/project_helpers_config').cloudHelper;
const testHelper = require('../../../helpers/test_helper.js');
const setting = require('../../../config/projects.js');
const pageHelper = require('../../../config/project_helpers_config').pageHelper;
const roleConfig = require('../../../config/research_role_config.js');
const { logEvent } = require('../../../../helpers/log_helper.js');
const { getNetworkStatus, listenNetworkStatus } = require('../../../../helpers/network_helper.js');

Page({
  /**
   * 页面的初始数据
   */
  data: {
    isAdmin: false,
    isLoading: true,
    simRoleEnabled: false,
    roleList: [],
    selectedRole: '',
    selectedRoleName: '',
    currentRole: '',
    roleName: '',
    simulationLogs: [],
    showLogs: false,
    activeTab: 'roles',
    compareData: null,
    
    // 角色列表从配置中获取
    roles: roleConfig.ROLES,
    
    // 添加角色配置引用到data中，使wxml可以访问
    roleConfig: roleConfig
  },

  /**
   * 生命周期函数--监听页面加载
   */
  onLoad: async function (options) {
    // 网络检测
    const net = await getNetworkStatus();
    if (!net.isConnected) {
      wx.showToast({ title: '当前无网络，请检查连接', icon: 'none' });
    } else if (net.networkType === '2g') {
      wx.showToast({ title: '当前为2G弱网，体验可能受影响', icon: 'none' });
    }
    listenNetworkStatus((res) => {
      if (!res.isConnected) wx.showToast({ title: '网络已断开', icon: 'none' });
      else if (res.networkType === '2g') wx.showToast({ title: '当前为2G弱网', icon: 'none' });
    });
    logEvent('page_load', { page: 'plm_role_simulation' });
    // 加载调试模式状态
    this._loadDebugMode();
    // 加载用户信息
    this._loadUserInfo();
    // 加载角色模拟日志
    this._loadSimulationLogs();
    // 加载角色权限对比表
    this._loadRoleCompareData();
  },
  
  /**
   * 加载调试模式状态
   */
  _loadDebugMode: function() {
    try {
      const isDebugMode = wx.getStorageSync('DEBUG_MODE_ENABLED') === true;
      const currentRole = wx.getStorageSync('DEBUG_CURRENT_ROLE') || '';
      const roleName = currentRole ? (roleConfig.getRoleById(currentRole)?.name || '未知角色') : '';
      
      this.setData({
        isDebugMode,
        currentRole,
        roleName
      });
    } catch (e) {
      console.error('[角色模拟] 加载调试模式状态失败', e);
    }
  },

  /**
   * 加载用户信息和权限
   */
  _loadUserInfo: async function () {
    try {
      this.setData({
        isLoading: true
      });

      let userInfo = null;
      
      try {
        // 尝试调用云函数获取用户信息
        const result = await cloudHelper.callCloud('user/my_detail', {}, {});
        userInfo = result;
      } catch (err) {
        console.error('[角色模拟] 调用云函数失败', err);
        // 使用模拟数据
        userInfo = {
          USER_NAME: '测试用户',
          USER_ROLES: ['software_engineer']
        };
      }
      
      // 检查是否是管理员
      const isAdmin = userInfo && userInfo.USER_ROLES && userInfo.USER_ROLES.includes('admin');
      
      // 获取角色模拟配置
      const simulationConfig = roleConfig.getRoleSimulationConfig(
        userInfo.USER_ROLES || []
      );
      
      this.setData({
        userInfo,
        isAdmin,
        simRoleEnabled: simulationConfig.enabled,
        isLoading: false
      });
      
    } catch (err) {
      console.error('[角色模拟] 加载用户信息失败', err);
      this.setData({
        isLoading: false
      });
      
      pageHelper.showNoneToast('加载失败，请重试');
    }
  },
  
  /**
   * 加载角色模拟日志
   */
  _loadSimulationLogs: function() {
    try {
      const logs = roleConfig.getRoleSimulationLogs();
      
      this.setData({
        simulationLogs: logs
      });
    } catch (err) {
      console.error('[角色模拟] 加载模拟日志失败', err);
    }
  },
  
  /**
   * 加载角色权限对比数据
   */
  _loadRoleCompareData: function() {
    try {
      // 获取权限矩阵数据
      const compareData = roleConfig.getRolePermissionMatrix();
      console.log('[权限对比] 加载权限矩阵数据:', JSON.stringify(compareData));
      
      if (!compareData || !compareData.permissions || !compareData.roles) {
        console.error('[权限对比] 权限矩阵数据结构不完整');
        pageHelper.showNoneToast('权限数据加载失败');
        return;
      }
      
      // 打印详细信息用于调试
      console.log('[权限对比] 角色数:', compareData.roles.length);
      console.log('[权限对比] 权限数:', compareData.permissions.length);
      
      // 检查数据结构
      const sampleRole = compareData.roles[0];
      const samplePerm = compareData.permissions[0];
      
      if (sampleRole && samplePerm && compareData.data) {
        // 打印数据格式示例，帮助调试
        console.log('[权限对比] 角色示例:', sampleRole);
        console.log('[权限对比] 权限示例:', samplePerm);
        console.log('[权限对比] 权限Map示例:', compareData.data[sampleRole.id]);
        if (compareData.data[sampleRole.id]) {
          const hasPermValue = compareData.data[sampleRole.id][samplePerm.code];
          console.log('[权限对比] 权限值示例:', 
                     `${sampleRole.name} 对 ${samplePerm.name} = ${hasPermValue}`);
        } else {
          console.error('[权限对比] 无法找到角色权限数据:', sampleRole.id);
        }
      } else {
        console.error('[权限对比] 数据结构不完整');
      }
      
      this.setData({
        compareData,
        isLoading: false
      });
    } catch (err) {
      console.error('[角色模拟] 加载角色比较数据失败', err);
      this.setData({
        isLoading: false
      });
      pageHelper.showNoneToast('权限数据加载失败');
    }
  },
  
  /**
   * 切换角色模拟开关
   */
  bindDebugSwitch: function(e) {
    console.log('[角色模拟] 调试模式开关被切换', e.detail.value);
    
    try {
      const enabled = e.detail.value;
      console.log('[角色模拟] 尝试设置调试模式为:', enabled);
      
      // 更新全局配置
      const success = roleConfig.setRoleSimulationEnabled(
        enabled, 
        this.data.userInfo.USER_ROLES || []
      );
      
      if (!success) {
        this.setData({
          isDebugMode: !enabled // 恢复原状态
        });
        
        pageHelper.showNoneToast('权限不足');
        return;
      }
      
      if (enabled) {
        // 开启调试模式
        wx.setStorageSync('DEBUG_MODE_ENABLED', true);
      } else {
        // 关闭调试模式并清除模拟角色
        wx.setStorageSync('DEBUG_MODE_ENABLED', false);
        
        // 清除角色
        this.bindResetRole();
      }
      
      // 更新本地状态
      this.setData({
        isDebugMode: enabled
      });
      
      pageHelper.showSuccessToast(`已${enabled ? '启用' : '禁用'}角色模拟`);
      
      // 刷新日志
      this._loadSimulationLogs();
      
      console.log('[角色模拟] 调试模式设置成功:', enabled);
    } catch (err) {
      console.error('[角色模拟] 切换角色模拟失败', err);
      pageHelper.showNoneToast('操作失败，请重试');
    }
  },
  
  /**
   * 选择角色
   */
  bindRoleSelect: function(e) {
    console.log('[角色模拟] 选择角色被点击', e.currentTarget.dataset);
    
    if (!this.data.isDebugMode) {
      pageHelper.showNoneToast('请先开启调试模式');
      return;
    }
    
    const roleId = e.currentTarget.dataset.role;
    console.log('[角色模拟] 选择的角色ID:', roleId);
    
    // 获取角色信息
    const role = roleConfig.getRoleById(roleId);
    if (!role) {
      pageHelper.showNoneToast('角色不存在');
      return;
    }
    
    // 切换模拟角色
    try {
      console.log('[角色模拟] 开始切换角色:', roleId);
      
      // 确保调试模式开启
      wx.setStorageSync('DEBUG_MODE_ENABLED', true);
      
      // 直接使用wx存储，确保角色状态被正确保存
      wx.setStorageSync('DEBUG_CURRENT_ROLE', roleId);
      wx.setStorageSync('current_simulated_role', roleId);
      
      // 更新UI状态
      this.setData({
        currentRole: roleId,
        roleName: role.name
      });
      
      // 显示成功提示
      pageHelper.showSuccessToast(`已切换为: ${role.name}`);
      
      // 记录角色切换日志
      this._createSimulationRecord(roleId);
      
      // 刷新日志
      this._loadSimulationLogs();
      
      console.log('[角色模拟] 角色切换成功:', roleId);
    } catch (err) {
      console.error('[角色模拟] 切换角色失败', err);
      pageHelper.showNoneToast('角色切换失败');
    }
  },
  
  /**
   * 重置角色
   */
  bindResetRole: function() {
    console.log('[角色模拟] 重置角色被点击');
    
    if (!this.data.isDebugMode) {
      pageHelper.showNoneToast('请先开启调试模式');
      return;
    }
    
    try {
      console.log('[角色模拟] 开始重置角色');
      
      // 清除存储中的角色信息
      wx.removeStorageSync('DEBUG_CURRENT_ROLE');
      wx.removeStorageSync('current_simulated_role');
      
      // 更新UI状态
      this.setData({
        currentRole: '',
        roleName: ''
      });
      
      // 显示成功消息
      pageHelper.showSuccessToast('已重置角色');
      
      // 记录重置操作
      this._createSimulationRecord('reset');
      
      // 刷新日志
      this._loadSimulationLogs();
      
      console.log('[角色模拟] 角色重置成功');
    } catch (err) {
      console.error('[角色模拟] 重置角色失败', err);
      pageHelper.showNoneToast('重置失败，请重试');
    }
  },
  
  /**
   * 切换标签页
   */
  bindTabSelect: function(e) {
    const tabId = e.currentTarget.dataset.id;
    
    this.setData({
      activeTab: tabId
    });
    
    if (tabId === 'compare') {
      this._loadRoleCompareData();
    } else if (tabId === 'logs') {
      this._loadSimulationLogs();
    }
  },
  
  /**
   * 清空日志
   */
  bindClearLogs: function() {
    if (!this.data.isAdmin) {
      pageHelper.showNoneToast('仅管理员可操作');
      return;
    }
    
    wx.showModal({
      title: '确认清空',
      content: '是否清空所有角色模拟日志？此操作不可恢复。',
      confirmText: '清空',
      confirmColor: '#FF0000',
      success: res => {
        if (res.confirm) {
          const success = roleConfig.clearRoleSimulationLogs();
          
          if (success) {
            this.setData({
              simulationLogs: []
            });
            
            pageHelper.showSuccessToast('日志已清空');
          } else {
            pageHelper.showNoneToast('清空失败，请重试');
          }
        }
      }
    });
  },
  
  /**
   * 创建角色模拟记录
   */
  async _createSimulationRecord(role) {
    try {
      const userInfo = this.data.userInfo;
      
      // 创建记录
      const logEntry = {
        role: role,
        roleName: role === 'reset' ? '重置角色' : roleConfig.getRoleName(role),
        timestamp: dayjs().valueOf(),
        userName: userInfo?.USER_NAME || '当前用户'
      };
      
      // 保存最近的模拟记录
      wx.setStorageSync('last_role_simulation', logEntry);
      
      // 如果启用了日志记录
      if (roleConfig.ROLE_SIMULATION.LOG_ACTIONS) {
        const logs = wx.getStorageSync('ROLE_SIMULATION_LOGS') || [];
        logs.unshift(logEntry);
        
        // 最多保留100条日志
        wx.setStorageSync('ROLE_SIMULATION_LOGS', logs.slice(0, 100));
      }
      
    } catch (err) {
      console.error('[角色模拟] 创建模拟记录失败', err);
    }
  },
  
  /**
   * 返回上一页
   */
  bindReturn: function() {
    wx.navigateBack();
  },
  
  /**
   * 展示角色权限详情
   */
  showRoleDetail: function(e) {
    const roleId = e.currentTarget.dataset.role;
    const role = roleConfig.getRoleById(roleId);
    
    if (!role) {
      pageHelper.showNoneToast('角色不存在');
      return;
    }
    
    const permissions = roleConfig.ROLE_PERMISSIONS[roleId] || [];
    
    wx.showModal({
      title: role.name + ' 权限',
      content: permissions.length > 0 ? 
        '拥有权限：\n' + permissions.join('\n') : 
        '该角色没有配置任何权限',
      showCancel: false
    });
  }
}); 